// 2013年版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式的约束
// 可以在许可证文件中找到的许可证。

// 此文件实现初始化和分配检查。

package types2

import "cmd/compile/internal/syntax"

// 赋值报告x是否可以赋值给T类型的变量，
// 如有必要，尝试将非类型化值转换为适当的
// 类型上下文描述分配发生的上下文。
// 使用T==nil表示对非类型化空白标识符的赋值。
// x、 如果分配失败，则模式设置为无效。
func (check *Checker) assignment(x *operand, T Type, context string) {
	check.singleValue(x)

	switch x.mode {
	case invalid:
		return // 以前报告的错误
	case constant_, variable, mapindex, value, nilvalue, commaok, commaerr:
		// 好啊
	default:
		// 我们可能因为其他问题（第39634期、第12期）而到达这里
		check.errorf(x, "cannot assign %s to %s in %s", x, T, context)
		return
	}

	if isUntyped(x.typ) {
		target := T
		// 规范：“如果一个非类型化常量被分配给接口变量
		// 类型或空白标识符，常数首先被转换为类型
		// bool、rune、int、float64、complex128或string，具体取决于
		// 关于值是否为布尔值、符文值、整数值、浮点值，
		// 复数或字符串常量。“
		if x.isNil() {
			if T == nil {
				check.errorf(x, "use of untyped nil in %s", context)
				x.mode = invalid
				return
			}
		} else if T == nil || IsInterface(T) {
			target = Default(x.typ)
		}
		newType, val, code := check.implicitTypeAndValue(x, target)
		if code != 0 {
			msg := check.sprintf("cannot use %s as %s value in %s", x, target, context)
			switch code {
			case _TruncatedFloat:
				msg += " (truncated)"
			case _NumericOverflow:
				msg += " (overflows)"
			}
			check.error(x, msg)
			x.mode = invalid
			return
		}
		if val != nil {
			x.val = val
			check.updateExprVal(x.expr, val)
		}
		if newType != x.typ {
			x.typ = newType
			check.updateExprType(x.expr, newType, false)
		}
	}
	// x、 类型已键入

	// 不能将通用（非实例化）函数值分配给变量。
	if sig := asSignature(x.typ); sig != nil && len(sig.tparams) > 0 {
		check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context)
	}

	// 规格说明：“如果左边是空白标识符，任何类型的或
	// 除预先声明的标识符nil之外的非常量值可能
	// 被分配给它。”
	if T == nil {
		return
	}

	reason := ""
	if ok, _ := x.assignableTo(check, T, &reason); !ok {
		if check.conf.CompilerErrorMessages {
			check.errorf(x, "incompatible type: cannot use %s as %s value", x, T)
		} else {
			if reason != "" {
				check.errorf(x, "cannot use %s as %s value in %s: %s", x, T, context, reason)
			} else {
				check.errorf(x, "cannot use %s as %s value in %s", x, T, context)
			}
		}
		x.mode = invalid
	}
}

func (check *Checker) initConst(lhs *Const, x *operand) {
	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
		if lhs.typ == nil {
			lhs.typ = Typ[Invalid]
		}
		return
	}

	// rhs必须是常数
	if x.mode != constant_ {
		check.errorf(x, "%s is not constant", x)
		if lhs.typ == nil {
			lhs.typ = Typ[Invalid]
		}
		return
	}
	assert(isConstType(x.typ))

	// 如果lhs还没有类型，请使用x类型。
	if lhs.typ == nil {
		lhs.typ = x.typ
	}

	check.assignment(x, lhs.typ, "constant declaration")
	if x.mode == invalid {
		return
	}

	lhs.val = x.val
}

func (check *Checker) initVar(lhs *Var, x *operand, context string) Type {
	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
		if lhs.typ == nil {
			lhs.typ = Typ[Invalid]
		}
		// 注意：这在go/types（https:
		// TODO（gri）：决定要执行的操作（还影响test/run.go排除列表）
		lhs.used = true // 避免后续“声明但未使用”错误
		return nil
	}

	// 如果lhs还没有类型，请使用x类型。
	if lhs.typ == nil {
		typ := x.typ
		if isUntyped(typ) {
			// 将非类型化类型转换为默认类型
			if typ == Typ[UntypedNil] {
				check.errorf(x, "use of untyped nil in %s", context)
				lhs.typ = Typ[Invalid]
				return nil
			}
			typ = Default(typ)
		}
		lhs.typ = typ
	}

	check.assignment(x, lhs.typ, context)
	if x.mode == invalid {
		return nil
	}

	return x.typ
}

func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
	if x.mode == invalid || x.typ == Typ[Invalid] {
		check.useLHS(lhs)
		return nil
	}

	// 确定lhs是否为标识符（可能加括号）。
	ident, _ := unparen(lhs).(*syntax.Name)

	// 如果它是空白标识符，则不评估LHS。
	if ident != nil && ident.Value == "_" {
		check.recordDef(ident, nil)
		check.assignment(x, nil, "assignment to _ identifier")
		if x.mode == invalid {
			return nil
		}
		return x.typ
	}

	// 如果lhs是表示变量v的标识符，则此赋值
	// 不是v的“用法”。记住v.used的当前值并还原
	// 通过check.expr评估lhs后。
	var v *Var
	var v_used bool
	if ident != nil {
		if obj := check.lookup(ident.Value); obj != nil {
			// 可以标记非局部变量，但忽略变量
			// 从其他包中删除，以避免与
			// 点导入变量。
			if w, _ := obj.(*Var); w != nil && w.pkg == check.pkg {
				v = w
				v_used = v.used
			}
		}
	}

	var z operand
	check.expr(&z, lhs)
	if v != nil {
		v.used = v_used // 恢复使用
	}

	if z.mode == invalid || z.typ == Typ[Invalid] {
		return nil
	}

	// 规范：“每个左侧操作数必须是可寻址的，映射索引
	// 表达式或空白标识符。操作数可以用括号括起来。”
	switch z.mode {
	case invalid:
		return nil
	case variable, mapindex:
		// 好啊
	case nilvalue:
		check.error(&z, "cannot assign to nil") // 默认情况下将打印“未键入的零”
		return nil
	default:
		if sel, ok := z.expr.(*syntax.SelectorExpr); ok {
			var op operand
			check.expr(&op, sel.X)
			if op.mode == mapindex {
				check.errorf(&z, "cannot assign to struct field %s in map", syntax.String(z.expr))
				return nil
			}
		}
		check.errorf(&z, "cannot assign to %s", &z)
		return nil
	}

	check.assignment(x, z.typ, "assignment")
	if x.mode == invalid {
		return nil
	}

	return x.typ
}

// 如果returnPos有效，则调用initVars来检查
// return表达式，returnPos是return语句的位置。
func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnPos syntax.Pos) {
	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2 && !returnPos.IsKnown())

	if len(lhs) != len(rhs) {
		// 使lhs失效
		for _, obj := range lhs {
			if obj.typ == nil {
				obj.typ = Typ[Invalid]
			}
		}
		// 如果我们已经报告了错误，请不要报告错误
		for _, x := range rhs {
			if x.mode == invalid {
				return
			}
		}
		if returnPos.IsKnown() {
			check.errorf(returnPos, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
			return
		}
		check.errorf(rhs[0], "cannot initialize %d variables with %d values", len(lhs), len(rhs))
		return
	}

	context := "assignment"
	if returnPos.IsKnown() {
		context = "return statement"
	}

	if commaOk {
		var a [2]Type
		for i := range a {
			a[i] = check.initVar(lhs[i], rhs[i], context)
		}
		check.recordCommaOkTypes(orig_rhs[0], a)
		return
	}

	for i, lhs := range lhs {
		check.initVar(lhs, rhs[i], context)
	}
}

func (check *Checker) assignVars(lhs, orig_rhs []syntax.Expr) {
	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2)

	if len(lhs) != len(rhs) {
		check.useLHS(lhs...)
		// 如果我们已经报告了错误，请不要报告错误
		for _, x := range rhs {
			if x.mode == invalid {
				return
			}
		}
		check.errorf(rhs[0], "cannot assign %d values to %d variables", len(rhs), len(lhs))
		return
	}

	if commaOk {
		var a [2]Type
		for i := range a {
			a[i] = check.assignVar(lhs[i], rhs[i])
		}
		check.recordCommaOkTypes(orig_rhs[0], a)
		return
	}

	for i, lhs := range lhs {
		check.assignVar(lhs, rhs[i])
	}
}

// 解包将*syntax.ListExpr解包到syntax.Expr的列表中。
// 为go/types->types2端口引入了助手。
// TODO（gri）应该找到一个更有效的解决方案，而不是
// 需要引入一个新的切片以简化
// 表达。
func unpackExpr(x syntax.Expr) []syntax.Expr {
	if x, _ := x.(*syntax.ListExpr); x != nil {
		return x.ElemList
	}
	if x != nil {
		return []syntax.Expr{x}
	}
	return nil
}

func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
	top := len(check.delayed)
	scope := check.scope

	// 收集lhs变量
	seen := make(map[string]bool, len(lhs))
	lhsVars := make([]*Var, len(lhs))
	newVars := make([]*Var, 0, len(lhs))
	hasErr := false
	for i, lhs := range lhs {
		ident, _ := lhs.(*syntax.Name)
		if ident == nil {
			check.useLHS(lhs)
			check.errorf(lhs, "non-name %s on left side of :=", lhs)
			hasErr = true
			continue
		}

		name := ident.Value
		if name != "_" {
			if seen[name] {
				check.errorf(lhs, "%s repeated on left side of :=", lhs)
				hasErr = true
				continue
			}
			seen[name] = true
		}

		// 如果重新声明标识，请使用正确的obj。这个
		// 变量的作用域在声明之后开始；所以我们
		// 必须使用Scope.Lookup here并调用Scope.Insert
		// （通过支票。申报）稍后。
		if alt := scope.Lookup(name); alt != nil {
			check.recordUse(ident, alt)
			// 重新声明的对象必须是变量
			if obj, _ := alt.(*Var); obj != nil {
				lhsVars[i] = obj
			} else {
				check.errorf(lhs, "cannot assign to %s", lhs)
				hasErr = true
			}
			continue
		}

		// 声明新变量
		obj := NewVar(ident.Pos(), check.pkg, name, nil)
		lhsVars[i] = obj
		if name != "_" {
			newVars = append(newVars, obj)
		}
		check.recordDef(ident, obj)
	}

	// 创建lhs无效的虚拟变量
	for i, obj := range lhsVars {
		if obj == nil {
			lhsVars[i] = NewVar(lhs[i].Pos(), check.pkg, "_", nil)
		}
	}

	check.initVars(lhsVars, rhs, nopos)

	// 范围更改前处理rhs表达式中的函数文字
	check.processDelayed(top)

	if len(newVars) == 0 && !hasErr {
		check.softErrorf(pos, "no new variables on left side of :=")
		return
	}

	// 声明新变量
	// spec:“内部声明的常量或变量标识符的范围
	// 函数从ConstSpec或VarSpec（ShortVarDecl）的末尾开始
	// 对于短变量声明），并在最内层的末尾结束
	// 包含块。”
	scopePos := syntax.EndPos(rhs[len(rhs)-1])
	for _, obj := range newVars {
		check.declare(scope, nil, obj, scopePos) // id=nil:recordDef已被调用
	}
}
